import { FILE_TYPES, SUPPORTED_EXTENSIONS, ERROR_CODES } from '../constants'

/**
 * 数据服务类
 * 处理数据导入、导出、解析等操作
 */
export class DataService {
  
  /**
   * 解析文件
   * @param {File} file 文件对象
   * @returns {Promise<Object>} 解析结果
   */
  static async parseFile(file) {
    try {
      const fileType = this.getFileType(file.name)
      const content = await this.readFile(file)
      
      switch (fileType) {
        case FILE_TYPES.CSV:
          return this.parseCSV(content)
        case FILE_TYPES.JSON:
          return this.parseJSON(content)
        case FILE_TYPES.EXCEL:
          return this.parseExcel(file)
        default:
          throw new Error(`不支持的文件类型: ${fileType}`)
      }
    } catch (error) {
      throw new Error(`文件解析失败: ${error.message}`)
    }
  }

  /**
   * 获取文件类型
   * @param {string} filename 文件名
   * @returns {string} 文件类型
   */
  static getFileType(filename) {
    const ext = filename.toLowerCase().split('.').pop()
    
    if (SUPPORTED_EXTENSIONS.EXCEL.includes(`.${ext}`)) {
      return FILE_TYPES.EXCEL
    } else if (SUPPORTED_EXTENSIONS.CSV.includes(`.${ext}`)) {
      return FILE_TYPES.CSV
    } else if (SUPPORTED_EXTENSIONS.JSON.includes(`.${ext}`)) {
      return FILE_TYPES.JSON
    }
    
    return 'unknown'
  }

  /**
   * 读取文件内容
   * @param {File} file 文件对象
   * @returns {Promise<string>} 文件内容
   */
  static readFile(file) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader()
      
      reader.onload = (e) => resolve(e.target.result)
      reader.onerror = () => reject(new Error('文件读取失败'))
      
      reader.readAsText(file, 'UTF-8')
    })
  }

  /**
   * 解析CSV文件
   * @param {string} content CSV内容
   * @returns {Object} 解析结果
   */
  static parseCSV(content) {
    const lines = content.split('\n').filter(line => line.trim())
    if (lines.length === 0) {
      throw new Error('CSV文件为空')
    }

    const headers = lines[0].split(',').map(h => h.trim().replace(/"/g, ''))
    const data = []

    for (let i = 1; i < lines.length; i++) {
      const values = lines[i].split(',').map(v => v.trim().replace(/"/g, ''))
      const row = {}
      
      headers.forEach((header, index) => {
        row[header] = this.parseValue(values[index] || '')
      })
      
      data.push(row)
    }

    const columns = headers.map(header => ({
      field: header,
      name: header,
      dataType: this.inferDataType(data, header)
    }))

    return {
      data,
      columns,
      rowCount: data.length
    }
  }

  /**
   * 解析JSON文件
   * @param {string} content JSON内容
   * @returns {Object} 解析结果
   */
  static parseJSON(content) {
    try {
      const jsonData = JSON.parse(content)
      let data = Array.isArray(jsonData) ? jsonData : [jsonData]
      
      if (data.length === 0) {
        throw new Error('JSON数据为空')
      }

      // 获取所有可能的字段
      const allFields = new Set()
      data.forEach(row => {
        Object.keys(row).forEach(key => allFields.add(key))
      })

      const columns = Array.from(allFields).map(field => ({
        field,
        name: field,
        dataType: this.inferDataType(data, field)
      }))

      return {
        data,
        columns,
        rowCount: data.length
      }
    } catch (error) {
      throw new Error(`JSON解析失败: ${error.message}`)
    }
  }

  /**
   * 解析Excel文件（模拟实现）
   * @param {File} file Excel文件
   * @returns {Promise<Object>} 解析结果
   */
  static async parseExcel(file) {
    // 这里应该使用真实的Excel解析库，如 xlsx
    // 现在提供模拟数据
    return new Promise((resolve) => {
      setTimeout(() => {
        const mockData = [
          { id: 1, name: '张三', age: 25, department: '技术部', salary: 8000 },
          { id: 2, name: '李四', age: 30, department: '销售部', salary: 6500 },
          { id: 3, name: '王五', age: 28, department: '技术部', salary: 9500 }
        ]

        const columns = [
          { field: 'id', name: 'ID', dataType: 'number' },
          { field: 'name', name: '姓名', dataType: 'text' },
          { field: 'age', name: '年龄', dataType: 'number' },
          { field: 'department', name: '部门', dataType: 'text' },
          { field: 'salary', name: '薪资', dataType: 'currency' }
        ]

        resolve({
          data: mockData,
          columns,
          rowCount: mockData.length
        })
      }, 1000)
    })
  }

  /**
   * 解析值的类型
   * @param {string} value 值
   * @returns {*} 解析后的值
   */
  static parseValue(value) {
    if (!value || value === '') return null
    
    // 尝试解析为数字
    if (!isNaN(value) && !isNaN(parseFloat(value))) {
      return parseFloat(value)
    }
    
    // 尝试解析为布尔值
    if (value.toLowerCase() === 'true') return true
    if (value.toLowerCase() === 'false') return false
    
    // 尝试解析为日期
    const date = new Date(value)
    if (!isNaN(date.getTime()) && value.match(/\d{4}-\d{2}-\d{2}/)) {
      return date.toISOString().split('T')[0]
    }
    
    return value
  }

  /**
   * 推断数据类型
   * @param {Array} data 数据数组
   * @param {string} field 字段名
   * @returns {string} 数据类型
   */
  static inferDataType(data, field) {
    const values = data.map(row => row[field]).filter(v => v != null && v !== '')
    
    if (values.length === 0) return 'text'
    
    // 检查是否为数字
    const numericValues = values.filter(v => !isNaN(v) && !isNaN(parseFloat(v)))
    if (numericValues.length / values.length > 0.8) {
      // 检查是否为货币
      if (field.toLowerCase().includes('price') || 
          field.toLowerCase().includes('salary') || 
          field.toLowerCase().includes('amount')) {
        return 'currency'
      }
      return 'number'
    }
    
    // 检查是否为日期
    const dateValues = values.filter(v => {
      const date = new Date(v)
      return !isNaN(date.getTime())
    })
    if (dateValues.length / values.length > 0.8) {
      return 'date'
    }
    
    // 检查是否为布尔值
    const boolValues = values.filter(v => 
      v === true || v === false || 
      v.toString().toLowerCase() === 'true' || 
      v.toString().toLowerCase() === 'false'
    )
    if (boolValues.length / values.length > 0.8) {
      return 'boolean'
    }
    
    return 'text'
  }

  /**
   * 导出数据为CSV
   * @param {Array} data 数据数组
   * @param {Array} columns 列定义
   * @returns {string} CSV内容
   */
  static exportToCSV(data, columns) {
    const headers = columns.map(col => col.name).join(',')
    const rows = data.map(row => 
      columns.map(col => {
        const value = row[col.field]
        return value != null ? `"${value}"` : '""'
      }).join(',')
    )
    
    return [headers, ...rows].join('\n')
  }

  /**
   * 导出数据为JSON
   * @param {Array} data 数据数组
   * @returns {string} JSON内容
   */
  static exportToJSON(data) {
    return JSON.stringify(data, null, 2)
  }

  /**
   * 验证文件
   * @param {File} file 文件对象
   * @param {Object} options 验证选项
   * @returns {Object} 验证结果
   */
  static validateFile(file, options = {}) {
    const {
      maxSize = 10 * 1024 * 1024, // 10MB
      allowedTypes = Object.values(FILE_TYPES)
    } = options

    const errors = []
    
    // 检查文件大小
    if (file.size > maxSize) {
      errors.push({
        code: ERROR_CODES.FILE_TOO_LARGE,
        message: `文件大小超过限制 (${Math.round(maxSize / 1024 / 1024)}MB)`
      })
    }
    
    // 检查文件类型
    const fileType = this.getFileType(file.name)
    if (!allowedTypes.includes(fileType)) {
      errors.push({
        code: ERROR_CODES.INVALID_FILE_TYPE,
        message: `不支持的文件类型: ${fileType}`
      })
    }
    
    return {
      isValid: errors.length === 0,
      errors
    }
  }
}



